home *** CD-ROM | disk | FTP | other *** search
/ Champak 146 / (Vol 146) Jan 07 2012.iso / Games / screamin_upstreamin.swf / scripts / DefineSprite_81 / frame_1 / DoAction.as
Text File  |  2012-01-07  |  63KB  |  1,045 lines

  1. var ┬º\x01┬º = 949;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 949)
  6.    {
  7.       set("\x01",eval("\x01") - 868);
  8.       ┬º┬ºpush(true);
  9.    }
  10.    else if(eval("\x01") == 804)
  11.    {
  12.       set("\x01",eval("\x01") - 696);
  13.    }
  14.    else
  15.    {
  16.       if(eval("\x01") == 203)
  17.       {
  18.          set("\x01",eval("\x01") - 133);
  19.          break;
  20.       }
  21.       if(eval("\x01") == 70)
  22.       {
  23.          set("\x01",eval("\x01") + 700);
  24.       }
  25.       else if(eval("\x01") == 438)
  26.       {
  27.          set("\x01",eval("\x01") + 501);
  28.       }
  29.       else if(eval("\x01") == 217)
  30.       {
  31.          set("\x01",eval("\x01") + 553);
  32.       }
  33.       else if(eval("\x01") == 81)
  34.       {
  35.          set("\x01",eval("\x01") + 646);
  36.          if(┬º┬ºpop())
  37.          {
  38.             set("\x01",eval("\x01") - 150);
  39.          }
  40.       }
  41.       else if(eval("\x01") == 830)
  42.       {
  43.          set("\x01",eval("\x01") - 722);
  44.       }
  45.       else
  46.       {
  47.          if(eval("\x01") == 328)
  48.          {
  49.             set("\x01",eval("\x01") + 332);
  50.             loadVariables(┬º┬ºpop(),┬º┬ºpop() === (┬º┬ºpop() & ┬º┬ºpop()));
  51.             break;
  52.          }
  53.          if(eval("\x01") == 29)
  54.          {
  55.             set("\x01",eval("\x01") + 801);
  56.             if(!┬º┬ºpop())
  57.             {
  58.                set("\x01",eval("\x01") - 660);
  59.                break;
  60.             }
  61.             break;
  62.          }
  63.          if(eval("\x01") == 442)
  64.          {
  65.             set("\x01",eval("\x01") - 239);
  66.             if(┬º┬ºpop())
  67.             {
  68.                set("\x01",eval("\x01") - 133);
  69.             }
  70.          }
  71.          else if(eval("\x01") == 17)
  72.          {
  73.             set("\x01",eval("\x01") + 757);
  74.             if(┬º┬ºpop())
  75.             {
  76.                set("\x01",eval("\x01") - 529);
  77.             }
  78.          }
  79.          else
  80.          {
  81.             if(eval("\x01") == 774)
  82.             {
  83.                set("\x01",eval("\x01") - 529);
  84.                break;
  85.             }
  86.             if(eval("\x01") == 721)
  87.             {
  88.                set("\x01",eval("\x01") - 692);
  89.                if(┬º┬ºpop())
  90.                {
  91.                   set("\x01",eval("\x01") + 801);
  92.                }
  93.             }
  94.             else if(eval("\x01") == 35)
  95.             {
  96.                set("\x01",eval("\x01") + 698);
  97.                ┬º┬ºpush(true);
  98.             }
  99.             else if(eval("\x01") == 245)
  100.             {
  101.                set("\x01",eval("\x01") + 694);
  102.             }
  103.             else if(eval("\x01") == 717)
  104.             {
  105.                set("\x01",eval("\x01") - 682);
  106.             }
  107.             else if(eval("\x01") == 867)
  108.             {
  109.                set("\x01",eval("\x01") + 94);
  110.             }
  111.             else if(eval("\x01") == 108)
  112.             {
  113.                set("\x01",eval("\x01") - 91);
  114.                ┬º┬ºpush(true);
  115.             }
  116.             else
  117.             {
  118.                if(eval("\x01") == 939)
  119.                {
  120.                   set("\x01",eval("\x01") - 934);
  121.                   stop();
  122.                   break;
  123.                }
  124.                if(eval("\x01") == 961)
  125.                {
  126.                   set("\x01",eval("\x01") - 133);
  127.                   ┬º┬ºpush(true);
  128.                }
  129.                else if(eval("\x01") == 577)
  130.                {
  131.                   set("\x01",eval("\x01") - 542);
  132.                }
  133.                else
  134.                {
  135.                   if(eval("\x01") == 200)
  136.                   {
  137.                      set("\x01",eval("\x01") + 667);
  138.                      while(true)
  139.                      {
  140.                         if(┬º┬ºpop() == 245)
  141.                         {
  142.                            set("\x01",eval("\x01") + 374);
  143.                         }
  144.                         else
  145.                         {
  146.                            if(eval("\x01") == 125)
  147.                            {
  148.                               set("\x01",eval("\x01") + 120);
  149.                               ┬º┬ºpush(┬º┬ºpop() - ┬º┬ºpop());
  150.                               loop5:
  151.                               while(true)
  152.                               {
  153.                                  set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  154.                                  ┬º┬ºpush(true);
  155.                                  while(eval("\x01") != 374)
  156.                                  {
  157.                                     if(eval("\x01") != 332)
  158.                                     {
  159.                                        if(eval("\x01") == 792)
  160.                                        {
  161.                                           set("\x01",eval("\x01") - 460);
  162.                                           if(┬º┬ºpop())
  163.                                           {
  164.                                              set("\x01",eval("\x01") - 24);
  165.                                           }
  166.                                        }
  167.                                        else if(eval("\x01") == 535)
  168.                                        {
  169.                                           set("\x01",eval("\x01") + 89);
  170.                                           if(┬º┬ºpop())
  171.                                           {
  172.                                              set("\x01",eval("\x01") + 65);
  173.                                           }
  174.                                        }
  175.                                        else if(eval("\x01") == 169)
  176.                                        {
  177.                                           set("\x01",eval("\x01") + 710);
  178.                                        }
  179.                                        else if(eval("\x01") == 456)
  180.                                        {
  181.                                           set("\x01",eval("\x01") + 172);
  182.                                        }
  183.                                        else if(eval("\x01") == 628)
  184.                                        {
  185.                                           set("\x01",eval("\x01") - 93);
  186.                                           ┬º┬ºpush(true);
  187.                                        }
  188.                                        else
  189.                                        {
  190.                                           if(eval("\x01") == 624)
  191.                                           {
  192.                                              set("\x01",eval("\x01") + 65);
  193.                                              break loop0;
  194.                                           }
  195.                                           if(eval("\x01") == 930)
  196.                                           {
  197.                                              set("\x01",eval("\x01") - 654);
  198.                                              ┬º┬ºpush(true);
  199.                                           }
  200.                                           else
  201.                                           {
  202.                                              if(eval("\x01") != 999)
  203.                                              {
  204.                                                 if(eval("\x01") == 452)
  205.                                                 {
  206.                                                    break loop5;
  207.                                                 }
  208.                                                 if(eval("\x01") == 445)
  209.                                                 {
  210.                                                    set("\x01",eval("\x01") + 485);
  211.                                                 }
  212.                                                 else
  213.                                                 {
  214.                                                    if(eval("\x01") == 879)
  215.                                                    {
  216.                                                       set("\x01",eval("\x01") + 101);
  217.                                                       _root.bigCar3Speed = 0;
  218.                                                       gotoAndStop(1);
  219.                                                       break loop0;
  220.                                                    }
  221.                                                    if(eval("\x01") == 308)
  222.                                                    {
  223.                                                       set("\x01",eval("\x01") + 622);
  224.                                                    }
  225.                                                    else if(eval("\x01") == 537)
  226.                                                    {
  227.                                                       set("\x01",eval("\x01") - 246);
  228.                                                    }
  229.                                                    else if(eval("\x01") == 123)
  230.                                                    {
  231.                                                       set("\x01",eval("\x01") + 756);
  232.                                                    }
  233.                                                    else if(eval("\x01") == 689)
  234.                                                    {
  235.                                                       set("\x01",eval("\x01") + 181);
  236.                                                    }
  237.                                                    else if(eval("\x01") == 291)
  238.                                                    {
  239.                                                       set("\x01",eval("\x01") + 501);
  240.                                                       ┬º┬ºpush(true);
  241.                                                    }
  242.                                                    else if(eval("\x01") == 538)
  243.                                                    {
  244.                                                       set("\x01",eval("\x01") + 332);
  245.                                                    }
  246.                                                    else if(eval("\x01") == 276)
  247.                                                    {
  248.                                                       set("\x01",eval("\x01") + 176);
  249.                                                       if(┬º┬ºpop())
  250.                                                       {
  251.                                                          set("\x01",eval("\x01") + 547);
  252.                                                       }
  253.                                                    }
  254.                                                    else if(eval("\x01") == 870)
  255.                                                    {
  256.                                                       set("\x01",eval("\x01") - 395);
  257.                                                       ┬º┬ºpush(true);
  258.                                                    }
  259.                                                    else if(eval("\x01") == 726)
  260.                                                    {
  261.                                                       set("\x01",eval("\x01") - 435);
  262.                                                    }
  263.                                                    else
  264.                                                    {
  265.                                                       if(eval("\x01") == 288)
  266.                                                       {
  267.                                                          set("\x01",eval("\x01") + 438);
  268.                                                          ┬º┬ºpush(ord(┬º┬ºpop()));
  269.                                                          break loop0;
  270.                                                       }
  271.                                                       if(eval("\x01") == 927)
  272.                                                       {
  273.                                                          set("\x01",eval("\x01") - 639);
  274.                                                          if(┬º┬ºpop())
  275.                                                          {
  276.                                                             set("\x01",eval("\x01") + 438);
  277.                                                          }
  278.                                                       }
  279.                                                       else
  280.                                                       {
  281.                                                          if(eval("\x01") == 56)
  282.                                                          {
  283.                                                             set("\x01",eval("\x01") + 113);
  284.                                                             ┬º┬ºpop() extends [];
  285.                                                             ┬º┬ºpush(┬º┬ºpop() gt ┬º┬ºpop() + new ┬º\┬º\┬ºpop()┬º());
  286.                                                             loop7:
  287.                                                             while(true)
  288.                                                             {
  289.                                                                set(┬º┬ºpop(),eval(┬º┬ºpop()) - 25);
  290.                                                                ┬º┬ºpush(true);
  291.                                                                while(true)
  292.                                                                {
  293.                                                                   if(eval("\x01") == 545)
  294.                                                                   {
  295.                                                                      set("\x01",eval("\x01") - 139);
  296.                                                                      ┬º┬ºpush(true);
  297.                                                                      continue;
  298.                                                                   }
  299.                                                                   if(eval("\x01") == 187)
  300.                                                                   {
  301.                                                                      set("\x01",eval("\x01") + 97);
  302.                                                                      continue;
  303.                                                                   }
  304.                                                                   if(eval("\x01") == 32)
  305.                                                                   {
  306.                                                                      set("\x01",eval("\x01") + 676);
  307.                                                                      if(┬º┬ºpop())
  308.                                                                      {
  309.                                                                         set("\x01",eval("\x01") - 185);
  310.                                                                      }
  311.                                                                      continue;
  312.                                                                   }
  313.                                                                   if(eval("\x01") == 399)
  314.                                                                   {
  315.                                                                      set("\x01",eval("\x01") + 497);
  316.                                                                      break loop0;
  317.                                                                   }
  318.                                                                   if(eval("\x01") == 831)
  319.                                                                   {
  320.                                                                      set("\x01",eval("\x01") - 642);
  321.                                                                      ┬º┬ºpush(true);
  322.                                                                      continue;
  323.                                                                   }
  324.                                                                   if(eval("\x01") == 634)
  325.                                                                   {
  326.                                                                      set("\x01",eval("\x01") - 447);
  327.                                                                      break loop0;
  328.                                                                   }
  329.                                                                   if(eval("\x01") == 357)
  330.                                                                   {
  331.                                                                      set("\x01",eval("\x01") + 42);
  332.                                                                      if(┬º┬ºpop())
  333.                                                                      {
  334.                                                                         set("\x01",eval("\x01") + 497);
  335.                                                                      }
  336.                                                                      continue;
  337.                                                                   }
  338.                                                                   if(eval("\x01") == 896)
  339.                                                                   {
  340.                                                                      set("\x01",eval("\x01") - 115);
  341.                                                                      continue;
  342.                                                                   }
  343.                                                                   if(eval("\x01") == 674)
  344.                                                                   {
  345.                                                                      set("\x01",eval("\x01") - 425);
  346.                                                                      continue;
  347.                                                                   }
  348.                                                                   if(eval("\x01") == 189)
  349.                                                                   {
  350.                                                                      set("\x01",eval("\x01") + 445);
  351.                                                                      if(┬º┬ºpop())
  352.                                                                      {
  353.                                                                         set("\x01",eval("\x01") - 447);
  354.                                                                      }
  355.                                                                      continue;
  356.                                                                   }
  357.                                                                   if(eval("\x01") == 431)
  358.                                                                   {
  359.                                                                      set("\x01",eval("\x01") - 182);
  360.                                                                      continue;
  361.                                                                   }
  362.                                                                   if(eval("\x01") == 40)
  363.                                                                   {
  364.                                                                      set("\x01",eval("\x01") + 244);
  365.                                                                      continue;
  366.                                                                   }
  367.                                                                   if(eval("\x01") == 866)
  368.                                                                   {
  369.                                                                      break;
  370.                                                                   }
  371.                                                                   if(eval("\x01") == 842)
  372.                                                                   {
  373.                                                                      set("\x01",eval("\x01") - 485);
  374.                                                                      ┬º┬ºpush(true);
  375.                                                                      continue;
  376.                                                                   }
  377.                                                                   if(eval("\x01") == 523)
  378.                                                                   {
  379.                                                                      set("\x01",eval("\x01") + 308);
  380.                                                                      continue;
  381.                                                                   }
  382.                                                                   if(eval("\x01") == 312)
  383.                                                                   {
  384.                                                                      set("\x01",eval("\x01") + 530);
  385.                                                                      continue;
  386.                                                                   }
  387.                                                                   if(eval("\x01") == 284)
  388.                                                                   {
  389.                                                                      set("\x01",eval("\x01") + 21);
  390.                                                                      ┬º┬ºpush(true);
  391.                                                                      continue;
  392.                                                                   }
  393.                                                                   if(eval("\x01") == 874)
  394.                                                                   {
  395.                                                                      set("\x01",eval("\x01") - 32);
  396.                                                                      continue;
  397.                                                                   }
  398.                                                                   if(eval("\x01") == 135)
  399.                                                                   {
  400.                                                                      set("\x01",eval("\x01") + 324);
  401.                                                                      continue;
  402.                                                                   }
  403.                                                                   if(eval("\x01") == 781)
  404.                                                                   {
  405.                                                                      set("\x01",eval("\x01") - 749);
  406.                                                                      ┬º┬ºpush(true);
  407.                                                                      continue;
  408.                                                                   }
  409.                                                                   if(eval("\x01") == 249)
  410.                                                                   {
  411.                                                                      set("\x01",eval("\x01") + 171);
  412.                                                                      continue;
  413.                                                                   }
  414.                                                                   if(eval("\x01") == 305)
  415.                                                                   {
  416.                                                                      set("\x01",eval("\x01") - 93);
  417.                                                                      if(┬º┬ºpop())
  418.                                                                      {
  419.                                                                         set("\x01",eval("\x01") + 718);
  420.                                                                      }
  421.                                                                      continue;
  422.                                                                   }
  423.                                                                   if(eval("\x01") == 800)
  424.                                                                   {
  425.                                                                      set("\x01",eval("\x01") + 74);
  426.                                                                      toggleHighQuality();
  427.                                                                      break loop0;
  428.                                                                   }
  429.                                                                   if(eval("\x01") == 406)
  430.                                                                   {
  431.                                                                      set("\x01",eval("\x01") + 394);
  432.                                                                      if(┬º┬ºpop())
  433.                                                                      {
  434.                                                                         set("\x01",eval("\x01") + 74);
  435.                                                                      }
  436.                                                                      continue;
  437.                                                                   }
  438.                                                                   if(eval("\x01") == 434)
  439.                                                                   {
  440.                                                                      set("\x01",eval("\x01") + 432);
  441.                                                                      if(┬º┬ºpop())
  442.                                                                      {
  443.                                                                         set("\x01",eval("\x01") - 435);
  444.                                                                      }
  445.                                                                      continue;
  446.                                                                   }
  447.                                                                   if(eval("\x01") == 930)
  448.                                                                   {
  449.                                                                      set("\x01",eval("\x01") - 91);
  450.                                                                      continue;
  451.                                                                   }
  452.                                                                   if(eval("\x01") == 811)
  453.                                                                   {
  454.                                                                      set("\x01",eval("\x01") - 30);
  455.                                                                      continue;
  456.                                                                   }
  457.                                                                   if(eval("\x01") == 420)
  458.                                                                   {
  459.                                                                      set("\x01",eval("\x01") + 177);
  460.                                                                      ┬º∩┐╜╚ï∩┐╜\x02'∩┐╜┬º++;
  461.                                                                      eval("∩┐╜∩┐╜1eiO")[┬º┬ºconstant(2)][┬º┬ºconstant(3)][┬º┬ºconstant(4)] += eval(┬º┬ºconstant(5));
  462.                                                                      eval("∩┐╜∩┐╜1eiO")[┬º┬ºconstant(2)][┬º┬ºconstant(3)][┬º┬ºconstant(6)] -= 5 + (5 - eval("∩┐╜╚ï∩┐╜\x02\'∩┐╜"));
  463.                                                                      break loop0;
  464.                                                                   }
  465.                                                                   if(eval("\x01") == 708)
  466.                                                                   {
  467.                                                                      set("\x01",eval("\x01") - 185);
  468.                                                                      break loop0;
  469.                                                                   }
  470.                                                                   if(eval("\x01") == 628)
  471.                                                                   {
  472.                                                                      set("\x01",eval("\x01") + 203);
  473.                                                                      continue;
  474.                                                                   }
  475.                                                                   if(eval("\x01") == 212)
  476.                                                                   {
  477.                                                                      break loop7;
  478.                                                                   }
  479.                                                                   if(eval("\x01") == 134)
  480.                                                                   {
  481.                                                                      set("\x01",eval("\x01") + 1);
  482.                                                                      stopAllSounds();
  483.                                                                      ┬º┬ºpush(┬º┬ºpop() or length(┬º┬ºpop()));
  484.                                                                      break loop0;
  485.                                                                   }
  486.                                                                   if(eval("\x01") == 549)
  487.                                                                   {
  488.                                                                      set("\x01",eval("\x01") - 415);
  489.                                                                      if(┬º┬ºpop())
  490.                                                                      {
  491.                                                                         set("\x01",eval("\x01") + 1);
  492.                                                                      }
  493.                                                                      continue;
  494.                                                                   }
  495.                                                                   if(eval("\x01") == 839)
  496.                                                                   {
  497.                                                                      set("\x01",eval("\x01") - 290);
  498.                                                                      ┬º┬ºpush(true);
  499.                                                                      continue;
  500.                                                                   }
  501.                                                                   if(eval("\x01") == 629)
  502.                                                                   {
  503.                                                                      set("\x01",eval("\x01") + 210);
  504.                                                                      continue;
  505.                                                                   }
  506.                                                                   if(eval("\x01") == 259)
  507.                                                                   {
  508.                                                                      set("\x01",eval("\x01") + 200);
  509.                                                                      continue;
  510.                                                                   }
  511.                                                                   if(eval("\x01") != 459)
  512.                                                                   {
  513.                                                                      if(eval("\x01") == 597)
  514.                                                                      {
  515.                                                                         set("\x01",eval("\x01") - 597);
  516.                                                                         break loop0;
  517.                                                                      }
  518.                                                                      break loop0;
  519.                                                                   }
  520.                                                                   continue loop7;
  521.                                                                }
  522.                                                                set("\x01",eval("\x01") - 435);
  523.                                                             }
  524.                                                             set("\x01",eval("\x01") + 718);
  525.                                                             break loop0;
  526.                                                          }
  527.                                                          if(eval("\x01") != 475)
  528.                                                          {
  529.                                                             if(eval("\x01") == 980)
  530.                                                             {
  531.                                                                set("\x01",eval("\x01") - 980);
  532.                                                                break loop0;
  533.                                                             }
  534.                                                             break loop0;
  535.                                                          }
  536.                                                          set("\x01",eval("\x01") - 419);
  537.                                                          if(┬º┬ºpop())
  538.                                                          {
  539.                                                             set("\x01",eval("\x01") + 113);
  540.                                                          }
  541.                                                       }
  542.                                                    }
  543.                                                 }
  544.                                                 continue;
  545.                                              }
  546.                                              ┬º┬ºpush("\x01");
  547.                                              ┬º┬ºpush(eval("\x01"));
  548.                                              ┬º┬ºpush(371);
  549.                                              set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  550.                                           }
  551.                                        }
  552.                                        continue;
  553.                                     }
  554.                                     set("\x01",eval("\x01") - 24);
  555.                                     loop9:
  556.                                     while(true)
  557.                                     {
  558.                                        addr51:
  559.                                        addr155:
  560.                                        while(true)
  561.                                        {
  562.                                           if(eval("\x01") == 945)
  563.                                           {
  564.                                              set("\x01",eval("\x01") - 721);
  565.                                              ┬º┬ºpush(true);
  566.                                           }
  567.                                           else if(eval("\x01") == 470)
  568.                                           {
  569.                                              set("\x01",eval("\x01") + 34);
  570.                                           }
  571.                                           else if(eval("\x01") == 743)
  572.                                           {
  573.                                              set("\x01",eval("\x01") - 270);
  574.                                              ┬º┬ºpush(true);
  575.                                           }
  576.                                           else
  577.                                           {
  578.                                              if(eval("\x01") == 428)
  579.                                              {
  580.                                                 set("\x01",eval("\x01") - 337);
  581.                                                 ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  582.                                                 break loop0;
  583.                                              }
  584.                                              if(eval("\x01") == 44)
  585.                                              {
  586.                                                 set("\x01",eval("\x01") + 460);
  587.                                              }
  588.                                              else
  589.                                              {
  590.                                                 if(eval("\x01") == 90)
  591.                                                 {
  592.                                                    set("\x01",eval("\x01") + 527);
  593.                                                    break loop0;
  594.                                                 }
  595.                                                 if(eval("\x01") == 40)
  596.                                                 {
  597.                                                    set("\x01",eval("\x01") + 11);
  598.                                                 }
  599.                                                 else
  600.                                                 {
  601.                                                    if(eval("\x01") == 5)
  602.                                                    {
  603.                                                       break;
  604.                                                    }
  605.                                                    if(eval("\x01") == 924)
  606.                                                    {
  607.                                                       set("\x01",eval("\x01") - 20);
  608.                                                       ┬º┬ºpush(true);
  609.                                                    }
  610.                                                    else
  611.                                                    {
  612.                                                       if(eval("\x01") == 528)
  613.                                                       {
  614.                                                          set("\x01",eval("\x01") - 111);
  615.                                                          break loop0;
  616.                                                       }
  617.                                                       if(eval("\x01") == 860)
  618.                                                       {
  619.                                                          set("\x01",eval("\x01") + 64);
  620.                                                       }
  621.                                                       else if(eval("\x01") == 91)
  622.                                                       {
  623.                                                          set("\x01",eval("\x01") - 80);
  624.                                                       }
  625.                                                       else if(eval("\x01") == 51)
  626.                                                       {
  627.                                                          set("\x01",eval("\x01") + 711);
  628.                                                          ┬º┬ºpush(true);
  629.                                                       }
  630.                                                       else if(eval("\x01") == 504)
  631.                                                       {
  632.                                                          set("\x01",eval("\x01") - 499);
  633.                                                          ┬º┬ºpush(true);
  634.                                                       }
  635.                                                       else if(eval("\x01") == 464)
  636.                                                       {
  637.                                                          set("\x01",eval("\x01") - 453);
  638.                                                       }
  639.                                                       else if(eval("\x01") == 24)
  640.                                                       {
  641.                                                          set("\x01",eval("\x01") + 719);
  642.                                                       }
  643.                                                       else if(eval("\x01") == 224)
  644.                                                       {
  645.                                                          set("\x01",eval("\x01") + 304);
  646.                                                          if(┬º┬ºpop())
  647.                                                          {
  648.                                                             set("\x01",eval("\x01") - 111);
  649.                                                          }
  650.                                                       }
  651.                                                       else if(eval("\x01") == 201)
  652.                                                       {
  653.                                                          set("\x01",eval("\x01") + 723);
  654.                                                       }
  655.                                                       else if(eval("\x01") == 865)
  656.                                                       {
  657.                                                          set("\x01",eval("\x01") - 433);
  658.                                                       }
  659.                                                       else if(eval("\x01") == 686)
  660.                                                       {
  661.                                                          set("\x01",eval("\x01") + 78);
  662.                                                       }
  663.                                                       else if(eval("\x01") == 904)
  664.                                                       {
  665.                                                          set("\x01",eval("\x01") - 476);
  666.                                                          if(┬º┬ºpop())
  667.                                                          {
  668.                                                             set("\x01",eval("\x01") - 337);
  669.                                                          }
  670.                                                       }
  671.                                                       else if(eval("\x01") == 809)
  672.                                                       {
  673.                                                          set("\x01",eval("\x01") - 627);
  674.                                                          ┬º┬ºpush(true);
  675.                                                       }
  676.                                                       else if(eval("\x01") == 473)
  677.                                                       {
  678.                                                          set("\x01",eval("\x01") - 383);
  679.                                                          if(┬º┬ºpop())
  680.                                                          {
  681.                                                             set("\x01",eval("\x01") + 527);
  682.                                                          }
  683.                                                       }
  684.                                                       else
  685.                                                       {
  686.                                                          if(eval("\x01") == 551)
  687.                                                          {
  688.                                                             set("\x01",eval("\x01") - 507);
  689.                                                             break loop0;
  690.                                                          }
  691.                                                          if(eval("\x01") == 463)
  692.                                                          {
  693.                                                             set("\x01",eval("\x01") - 262);
  694.                                                             ┬º┬ºpush({});
  695.                                                             break loop0;
  696.                                                          }
  697.                                                          if(eval("\x01") == 876)
  698.                                                          {
  699.                                                             set("\x01",eval("\x01") - 325);
  700.                                                             if(┬º┬ºpop())
  701.                                                             {
  702.                                                                set("\x01",eval("\x01") - 507);
  703.                                                             }
  704.                                                          }
  705.                                                          else if(eval("\x01") == 417)
  706.                                                          {
  707.                                                             set("\x01",eval("\x01") - 366);
  708.                                                          }
  709.                                                          else if(eval("\x01") == 432)
  710.                                                          {
  711.                                                             set("\x01",eval("\x01") + 444);
  712.                                                             ┬º┬ºpush(true);
  713.                                                          }
  714.                                                          else
  715.                                                          {
  716.                                                             if(eval("\x01") == 570)
  717.                                                             {
  718.                                                                set("\x01",eval("\x01") - 276);
  719.                                                                break loop0;
  720.                                                             }
  721.                                                             if(eval("\x01") == 617)
  722.                                                             {
  723.                                                                set("\x01",eval("\x01") + 192);
  724.                                                             }
  725.                                                             else
  726.                                                             {
  727.                                                                if(eval("\x01") == 11)
  728.                                                                {
  729.                                                                   addr503:
  730.                                                                   set("\x01",eval("\x01") + 429);
  731.                                                                   _root.helpDisplay._visible = false;
  732.                                                                   break loop0;
  733.                                                                }
  734.                                                                if(eval("\x01") == 901)
  735.                                                                {
  736.                                                                   set("\x01",eval("\x01") - 469);
  737.                                                                }
  738.                                                                else
  739.                                                                {
  740.                                                                   if(eval("\x01") == 440)
  741.                                                                   {
  742.                                                                      set("\x01",eval("\x01") - 440);
  743.                                                                      break loop0;
  744.                                                                   }
  745.                                                                   if(eval("\x01") == 477)
  746.                                                                   {
  747.                                                                      set("\x01",eval("\x01") + 287);
  748.                                                                   }
  749.                                                                   else
  750.                                                                   {
  751.                                                                      if(eval("\x01") == 817)
  752.                                                                      {
  753.                                                                         set("\x01",eval("\x01") + 48);
  754.                                                                         break loop0;
  755.                                                                      }
  756.                                                                      if(eval("\x01") == 764)
  757.                                                                      {
  758.                                                                         set("\x01",eval("\x01") + 16);
  759.                                                                         ┬º┬ºpush(true);
  760.                                                                      }
  761.                                                                      else if(eval("\x01") == 762)
  762.                                                                      {
  763.                                                                         set("\x01",eval("\x01") + 97);
  764.                                                                         if(┬º┬ºpop())
  765.                                                                         {
  766.                                                                            set("\x01",eval("\x01") - 382);
  767.                                                                         }
  768.                                                                      }
  769.                                                                      else
  770.                                                                      {
  771.                                                                         if(eval("\x01") == 859)
  772.                                                                         {
  773.                                                                            set("\x01",eval("\x01") - 382);
  774.                                                                            break loop0;
  775.                                                                         }
  776.                                                                         if(eval("\x01") == 780)
  777.                                                                         {
  778.                                                                            set("\x01",eval("\x01") - 210);
  779.                                                                            if(┬º┬ºpop())
  780.                                                                            {
  781.                                                                               set("\x01",eval("\x01") - 276);
  782.                                                                            }
  783.                                                                            continue loop9;
  784.                                                                         }
  785.                                                                         if(eval("\x01") == 294)
  786.                                                                         {
  787.                                                                            set("\x01",eval("\x01") + 449);
  788.                                                                         }
  789.                                                                         else if(eval("\x01") == 182)
  790.                                                                         {
  791.                                                                            set("\x01",eval("\x01") + 635);
  792.                                                                            if(┬º┬ºpop())
  793.                                                                            {
  794.                                                                               set("\x01",eval("\x01") + 48);
  795.                                                                            }
  796.                                                                         }
  797.                                                                         else
  798.                                                                         {
  799.                                                                            if(eval("\x01") != 823)
  800.                                                                            {
  801.                                                                               break loop0;
  802.                                                                            }
  803.                                                                            set("\x01",eval("\x01") - 14);
  804.                                                                         }
  805.                                                                      }
  806.                                                                   }
  807.                                                                }
  808.                                                             }
  809.                                                          }
  810.                                                       }
  811.                                                    }
  812.                                                 }
  813.                                              }
  814.                                           }
  815.                                        }
  816.                                        ┬º┬ºpush("\x01");
  817.                                        ┬º┬ºpush("\x01");
  818.                                     }
  819.                                  }
  820.                               }
  821.                               set("\x01",eval("\x01") + 547);
  822.                               try
  823.                               {
  824.                               }
  825.                               finally
  826.                               {
  827.                               }
  828.                               break loop0;
  829.                            }
  830.                            if(eval("\x01") == 371)
  831.                            {
  832.                               set("\x01",eval("\x01") + 143);
  833.                               addr719:
  834.                               ┬º┬ºpush(true);
  835.                               while(true)
  836.                               {
  837.                                  if(eval("\x01") == 119)
  838.                                  {
  839.                                     set("\x01",eval("\x01") + 109);
  840.                                     ┬º┬ºpush(true);
  841.                                     continue;
  842.                                  }
  843.                                  if(eval("\x01") == 362)
  844.                                  {
  845.                                     set("\x01",eval("\x01") + 257);
  846.                                     continue;
  847.                                  }
  848.                                  if(eval("\x01") != 790)
  849.                                  {
  850.                                     if(eval("\x01") == 873)
  851.                                     {
  852.                                        set("\x01",eval("\x01") + 74);
  853.                                     }
  854.                                     else if(eval("\x01") == 619)
  855.                                     {
  856.                                        set("\x01",eval("\x01") + 339);
  857.                                        ┬º┬ºpush(true);
  858.                                     }
  859.                                     else if(eval("\x01") == 734)
  860.                                     {
  861.                                        set("\x01",eval("\x01") + 213);
  862.                                     }
  863.                                     else
  864.                                     {
  865.                                        if(eval("\x01") == 638)
  866.                                        {
  867.                                           set("\x01",eval("\x01") + 83);
  868.                                           removeMovieClip(┬º┬ºpop() == ┬º┬ºpop() >>> ┬º┬ºpop());
  869.                                           break loop0;
  870.                                        }
  871.                                        if(eval("\x01") == 721)
  872.                                        {
  873.                                           set("\x01",eval("\x01") - 350);
  874.                                        }
  875.                                        else if(eval("\x01") == 958)
  876.                                        {
  877.                                           set("\x01",eval("\x01") - 320);
  878.                                           if(┬º┬ºpop())
  879.                                           {
  880.                                              set("\x01",eval("\x01") + 83);
  881.                                           }
  882.                                        }
  883.                                        else
  884.                                        {
  885.                                           if(eval("\x01") != 634)
  886.                                           {
  887.                                              break;
  888.                                           }
  889.                                           set("\x01",eval("\x01") - 263);
  890.                                        }
  891.                                     }
  892.                                     continue;
  893.                                  }
  894.                                  set("\x01",eval("\x01") + 83);
  895.                               }
  896.                               continue;
  897.                               addr719:
  898.                            }
  899.                            else
  900.                            {
  901.                               if(eval("\x01") == 219)
  902.                               {
  903.                                  set("\x01",eval("\x01") - 94);
  904.                                  if(┬º┬ºpop())
  905.                                  {
  906.                                     set("\x01",eval("\x01") + 120);
  907.                                  }
  908.                               }
  909.                               else if(eval("\x01") == 947)
  910.                               {
  911.                                  set("\x01",eval("\x01") - 728);
  912.                                  ┬º┬ºgoto(addr719);
  913.                                  ┬º┬ºpush(true);
  914.                               }
  915.                               else
  916.                               {
  917.                                  if(eval("\x01") == 208)
  918.                                  {
  919.                                     set("\x01",eval("\x01") - 90);
  920.                                     stop();
  921.                                     break loop0;
  922.                                  }
  923.                                  if(eval("\x01") == 667)
  924.                                  {
  925.                                     set("\x01",eval("\x01") - 459);
  926.                                  }
  927.                                  else if(eval("\x01") == 643)
  928.                                  {
  929.                                     set("\x01",eval("\x01") - 435);
  930.                                  }
  931.                                  else if(eval("\x01") == 228)
  932.                                  {
  933.                                     set("\x01",eval("\x01") + 562);
  934.                                     if(┬º┬ºpop())
  935.                                     {
  936.                                        set("\x01",eval("\x01") + 83);
  937.                                     }
  938.                                  }
  939.                                  else
  940.                                  {
  941.                                     if(eval("\x01") == 792)
  942.                                     {
  943.                                        break;
  944.                                     }
  945.                                     if(eval("\x01") != 514)
  946.                                     {
  947.                                        if(eval("\x01") == 118)
  948.                                        {
  949.                                           set("\x01",eval("\x01") - 118);
  950.                                           break loop0;
  951.                                        }
  952.                                        break loop0;
  953.                                     }
  954.                                     set("\x01",eval("\x01") + 278);
  955.                                     if(┬º┬ºpop())
  956.                                     {
  957.                                        set("\x01",eval("\x01") - 149);
  958.                                     }
  959.                                  }
  960.                                  ┬º┬ºgoto(addr719);
  961.                               }
  962.                               ┬º┬ºgoto(addr719);
  963.                            }
  964.                            ┬º┬ºgoto(addr719);
  965.                            while(true)
  966.                            {
  967.                               set(┬º┬ºpop(),eval(┬º┬ºpop()) + 458);
  968.                               if(┬º┬ºpop())
  969.                               {
  970.                                  set("\x01",eval("\x01") - 262);
  971.                               }
  972.                               ┬º┬ºgoto(addr51);
  973.                               ┬º┬ºgoto(addr155);
  974.                            }
  975.                            ┬º┬ºgoto(addr503);
  976.                         }
  977.                         ┬º┬ºgoto(addr719);
  978.                      }
  979.                      set("\x01",eval("\x01") - 149);
  980.                      String(┬º┬ºpop());
  981.                   }
  982.                   if(eval("\x01") == 5)
  983.                   {
  984.                      set("\x01",eval("\x01") - 5);
  985.                      break;
  986.                   }
  987.                   if(eval("\x01") == 828)
  988.                   {
  989.                      set("\x01",eval("\x01") - 500);
  990.                      if(┬º┬ºpop())
  991.                      {
  992.                         set("\x01",eval("\x01") + 332);
  993.                      }
  994.                   }
  995.                   else if(eval("\x01") == 660)
  996.                   {
  997.                      set("\x01",eval("\x01") - 514);
  998.                   }
  999.                   else if(eval("\x01") == 770)
  1000.                   {
  1001.                      set("\x01",eval("\x01") - 49);
  1002.                      ┬º┬ºpush(true);
  1003.                   }
  1004.                   else
  1005.                   {
  1006.                      if(eval("\x01") == 727)
  1007.                      {
  1008.                         set("\x01",eval("\x01") - 150);
  1009.                         ┬º┬ºpop()[┬º┬ºpop()] = [];
  1010.                         ┬º┬ºpush(chr(┬º┬ºpop()));
  1011.                         break;
  1012.                      }
  1013.                      if(eval("\x01") == 146)
  1014.                      {
  1015.                         set("\x01",eval("\x01") + 296);
  1016.                         ┬º┬ºpush(true);
  1017.                      }
  1018.                      else if(eval("\x01") == 703)
  1019.                      {
  1020.                         set("\x01",eval("\x01") - 557);
  1021.                      }
  1022.                      else if(eval("\x01") == 733)
  1023.                      {
  1024.                         set("\x01",eval("\x01") - 533);
  1025.                         if(┬º┬ºpop())
  1026.                         {
  1027.                            set("\x01",eval("\x01") + 667);
  1028.                         }
  1029.                      }
  1030.                      else
  1031.                      {
  1032.                         if(eval("\x01") != 269)
  1033.                         {
  1034.                            break;
  1035.                         }
  1036.                         set("\x01",eval("\x01") + 692);
  1037.                      }
  1038.                   }
  1039.                }
  1040.             }
  1041.          }
  1042.       }
  1043.    }
  1044. }
  1045.